//package com.gosling.cloudspace.service;
//
//import io.swagger.annotations.Api;
//import org.dom4j.Document;
//import org.dom4j.DocumentHelper;
//import org.dom4j.Element;
//import org.dom4j.Node;
//import org.dom4j.io.SAXReader;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//
//import javax.xml.stream.XMLStreamWriter;
//import java.util.LinkedHashMap;
//import java.util.List;
//
///**
// * 根据档案类型封装数据包工具类
// *
// * @Software: IntelliJ IDEA
// * @Addresses: www.gosling.com
// * @Email 1793327033@qq.com
// * @classname XmlDataPackgeUtils
// * @author: lihonglin
// * @date: 2021/6/28 11:26
// */
//@SuppressWarnings("all")
//@Api(value = "根据档案类型封装数据包工具类")
//public class XmlDataPackgeUtils3 {
//   public final static String[] decodeStr = new String[]{
//           "doc", "docx", "jpg", "jpeg", "zip", "png", "bmp", "gif", "tif",
//           "tiff", "pdf", "ppt", "xls", "xlsx", "pptx", "avi", "flv", "wmv", "htm", "html"
//   };
//   protected static final Logger logger = LoggerFactory.getLogger(XmlDataPackgeUtils3.class);
//   private final static Integer EDIT_CODE = 2;
//   /***
//    * dom4j读取文件后没有关流的方法
//    * 调用gc垃圾回收可以强制关闭流
//    * 但是只是 System.gc() 的话是通知gc来回收垃圾
//    * gc里面判断runFinalization=true才会执行垃圾回收
//    * 所以要配合runFinalization使用
//    */
//   static void gcAndFinalize() throws Exception {
//      System.gc();
//      System.runFinalization();
//      System.gc();
//      Thread.sleep(30);
//   }
//
//   public Result2Xml createNewXml(List<Element> elementsList, Document orgDocument, Element originRoot, ArchiveInfoJson archiveInfoJson, List<LinkedHashMap> electronicRecords, boolean status, Element nrms, Element signElement, Integer edit) {
//      XMLStreamWriter xsw = null;
//      try {
//         if (edit.equals(EDIT_CODE)) {
//            //修订多次(nrms = sign)
//            Result2Xml result2Xml = getResult2Xml(elementsList, originRoot, archiveInfoJson, electronicRecords, status);
//            Document document = new SAXReader().read(archiveInfoJson.getFilePathAll());
//            Element rootElement = document.getRootElement();
//            Element element = rootElement.element("被签名对象").element("封装内容");
//            element.setName("修订内容");
//            Document newDocument = DocumentHelper.createDocument();
//            Element newRssFilePackgeElement = newDocument.addElement("电子文件封装包", "http://www.saac.gov.cn/standards/ERM/encapsulation");
//            newRssFilePackgeElement.addNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");
//            newRssFilePackgeElement.addAttribute("xsi:schemaLocation", "http://www.saac.gov.cn/standards/ERM/encapsulation eep.xsd");
//            newRssFilePackgeElement.addElement("封装包格式描述").setText("本EEP根据中华人民共和国档案行业标准DA/T 48-2009《基于XML的电子文件封装规范》生成");
//            newRssFilePackgeElement.addElement("版本").setText("2009");
//            Node oldSignElment = orgDocument.getRootElement().element("被签名对象");
//            oldSignElment.setParent(null);
//            newRssFilePackgeElement.add(oldSignElment);
//            newRssFilePackgeElement.element("被签名对象").remove(newRssFilePackgeElement.element("被签名对象").getNamespace());
//            oldSignElment.setParent(newRssFilePackgeElement);
//            Element editElement = newDocument.getRootElement().element("被签名对象").element("修改封装内容");
//            Element tagNum = editElement.element("修改标识符");
//            tagNumber2(archiveInfoJson, tagNum);
//            //添加修订内容
//            element.setParent(null);
//            editElement.add(element);
//         } else {
//            //true 即将封装为修订包
//            if (status && edit == 1) {
//               //已经生成过XML，但未作出修改
//               Result2Xml result2Xml = getResult2Xml(elementsList, originRoot, archiveInfoJson, electronicRecords, status);
//               Document document = new SAXReader().read(archiveInfoJson.getFilePathAll());
//               Element rootElement = document.getRootElement();
//               Element element = rootElement.element("被签名对象").element("封装内容");
//               element.setName("修订内容");
//
//               Document newDocument = DocumentHelper.createDocument();
//               Element newRssFilePackgeElement = newDocument.addElement("电子文件封装包", "http://www.saac.gov.cn/standards/ERM/encapsulation");
//               newRssFilePackgeElement.addNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");
//               newRssFilePackgeElement.addAttribute("xsi:schemaLocation", "http://www.saac.gov.cn/standards/ERM/encapsulation eep.xsd");
//               newRssFilePackgeElement.addElement("封装包格式描述").setText("本EEP根据中华人民共和国档案行业标准DA/T 48-2009《基于XML的电子文件封装规范》生成");
//               newRssFilePackgeElement.addElement("版本").setText("2009");
//               Element sign = newRssFilePackgeElement.addElement("被签名对象").addAttribute("eep版本", "2009");
//               sign.addElement("封装包类型").setText( "修改型");
//               Element t = sign.addElement("封装包类型描述");
//               t.setText("本封装包包含电子文件数据及其元数据，系修改封装，在保留原封装包的基础上，添加了修改层");
//               sign.addElement("封装包创建时间").setText(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").format(new Date(System.currentTimeMillis())));
//               Element unit = sign.addElement("封装包创建单位");
//               unit.setText(archiveInfoJson.getFondsName() != null ? archiveInfoJson.getFondsName() : "单位名称");
//
//               Element content = sign.addElement("修改封装内容");
//               Element tag = content.addElement("修改标识符");
//               tagNumber2(archiveInfoJson, tag);
//               Element originPack = content.addElement("原封装包");
//               //原封装包内容和修订内容进行拼接//被签名对象//电子签名块
//               nrms.setParent(null);
//               originPack.add(nrms);
//               signElement.setParent(null);
//               originPack.add(signElement);
//               //添加修订内容
//               element.setParent(null);
//               content.add(element);
//            } else {
//               //false为原始包
//               return getResult2Xml(elementsList, originRoot, archiveInfoJson, electronicRecords, status);
//            }
//         }
//      } catch (Exception e) {
//         e.printStackTrace();
//      }
//      return null;
//   }
//
//   /***
//    * 生成XML的核心方法
//    *
//    * @param elementsList        原方法的电子文件列表
//    * @param originRoot          原方法的document
//    * @param archiveInfoJson     通用实体类
//    * @param electronicRecords   电子文件
//    * @param status              归档状态
//    * @return
//    * @throws Exception
//    */
//   private Result2Xml getResult2Xml(List<Element> elementsList, Element originRoot, ArchiveInfoJson archiveInfoJson, List<LinkedHashMap> electronicRecords, boolean status) throws Exception {
//      XMLStreamWriter xsw;
//      LinkedHashMap map = archiveInfoJson.getMap();
//      LinkedHashMap activeMap = archiveInfoJson.getActiveMap();
//      String archiveId = archiveInfoJson.getArchiveId();
//      //设置文件保存路径，设置并保存xml内容部分
//      String pathname = setAndSaveXml(archiveInfoJson, activeMap, archiveId);
//      xsw = XMLOutputFactory.newInstance().createXMLStreamWriter(new FileOutputStream(pathname), "UTF-8");
//      xsw.writeStartDocument("UTF-8", "1.0");
//      xsw.writeStartElement("电子文件封装包");
//      xsw.writeNamespace("", "http://www.saac.gov.cn/standards/ERM/encapsulation");
//      xsw.writeNamespace("xsi", " http://www.w3.org/2001/XMLSchema-instance");
//      xsw.writeAttribute("xsi:schemaLocation", "http://www.saac.gov.cn/standards/ERM/encapsulation eep.xsd");
//      setSaxElement(xsw, "封装包格式描述", "本EEP根据中华人民共和国档案行业标准DA/T 48-2009《基于XML的电子文件封装规范》生成");
//      setSaxElement(xsw, "版本", "2009");
//      xsw.writeStartElement("被签名对象");
//      xsw.writeAttribute("eep版本", "2009");
//      setSaxElement(xsw, "封装包类型", "原始型");
//      setSaxElement(xsw, "封装包类型描述", "本封装包包含电子文件数据及其元数据，原始封装，未经修改");
//      String dateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").format(new Date(System.currentTimeMillis()));
//      archiveInfoJson.setTitle(Objects.isNull(activeMap.get("title")) ? "" : activeMap.get("title").toString());
//      setSaxElement(xsw, "封装包创建时间", dateTime);
//      setSaxElement(xsw, "封装包创建单位", archiveInfoJson.getFondsName() != null ? archiveInfoJson.getFondsName() : "单位名称");
//      xsw.writeStartElement("封装内容");
//      xsw.writeStartElement("文件实体块");
//      xsw.writeStartElement("文件实体");
//      setSaxElement(xsw, "聚合层次", archiveInfoJson.getTableDisplayName());
//      xsw.writeStartElement("来源");
//      originStart(archiveInfoJson, xsw);
//      xsw.writeEndElement();//来源
//      setSaxElement(xsw, "电子文件号", activeMap.get("id").toString());
//      xsw.writeStartElement("档号");
//      partyNum(archiveInfoJson, xsw);
//      xsw.writeEndElement();//档号
//      xsw.writeStartElement("内容描述");
//      fileNumAndContentDes(archiveInfoJson, xsw);
//      xsw.writeEndElement();//内容描述
//      int size = electronicRecords.size();
//      xsw.writeStartElement("形式特征");
//      characteristic(archiveInfoJson, xsw, map, activeMap, size, status);
//      xsw.writeEndElement();//形式特征
//      xsw.writeStartElement("存储位置");
//      vehicleInformation(archiveInfoJson, xsw);
//      xsw.writeEndElement();//存储位置
//      xsw.writeStartElement("权限管理");
//      setSaxElement(xsw, "知识产权说明", "d://");
//      xsw.writeStartElement("授权");
//      setSaxElement(xsw, "授权对象");
//      setSaxElement(xsw, "授权行为");
//      xsw.writeEndElement();//授权
//      setSaxElement(xsw, "控制标识");
//      xsw.writeEndElement();//权限管理
//      setSaxElement(xsw, "信息系统描述", "DA/T 48 XML文件封装");
//      setSaxElement(xsw, "附注");
//      xsw.writeStartElement("文件数据");
//      String xmlFileId = IDTool.uuid2();
//      //如果为文件
//      if (archiveInfoJson.getTableName().contains("_document")) {
//         //如果电子文件数量为0 则不添加文档数据
//         if (forEletronic(xsw, elementsList, archiveInfoJson, electronicRecords, status, activeMap, size, xmlFileId, originRoot)) {
//            logger.error(CommonCodeEnum.XML_ERROR.getMessage());
//            return Result2Xml.failed(CommonCodeEnum.XML_ERROR);
//         }
//      } else if (archiveInfoJson.getTableName().contains("_vol")) {
//         //如果为案卷
//         if (forDocuments(xsw, elementsList, originRoot, archiveInfoJson, status, activeMap, xmlFileId, archiveId)) {
//            logger.error(CommonCodeEnum.GET_OBJ_NULL_ERROR.getMessage());
//            return Result2Xml.failed(CommonCodeEnum.GET_OBJ_NULL_ERROR);
//         }
//      }
//      xsw.writeEndElement();//文件数据
//      xsw.writeEndElement();//文件实体
//      xsw.writeStartElement("文件实体关系");
//      boolean vol = archiveInfoJson.getTableName().contains("_vol");
//      setSaxElement(xsw, "文件标识符", !vol ? archiveInfoJson.getArchiveId() : "");
//      setSaxElement(xsw, "被关联文件标识符", !vol ? archiveInfoJson.getArchiveId() : "");
//      setSaxElement(xsw, "关系类型");
//      setSaxElement(xsw, "关系");
//      setSaxElement(xsw, "关系描述");
//      xsw.writeEndElement();//文件实体关系
//      xsw.writeEndElement();//文件实体块
//      Map archHash = archiveInfoJson.getHash();
//      String operator = "0";
//      Timestamp createTimeStr = new Timestamp(System.currentTimeMillis());
//      archiveInfoJson.setLogId(archiveId);
//      if (archHash != null) {
//         operator = Objects.isNull(archHash.get("h_operattype")) ? "0" : archHash.get("h_operattype").toString();
//         createTimeStr = Objects.isNull(archHash.get("h_createtime")) ? createTimeStr : (Timestamp) archHash.get("h_createtime");
//         archiveInfoJson.setLogId(Objects.isNull(archHash.get("id")) ? archiveId : archHash.get("id").toString());
//      }
//      xsw.writeStartElement("业务实体块");
//      xsw.writeStartElement("业务实体");
//      setSaxElement(xsw, "业务标识符", archiveInfoJson.getLogId());
//      setSaxElement(xsw, "机构人员标识符", archiveInfoJson.getOrganizationPersonId());
//      setSaxElement(xsw, "文件标识符", !vol ? archiveInfoJson.getArchiveId() : "");
//      setSaxElement(xsw, "业务状态", "历史行为");
//      setSaxElement(xsw, "业务行为", "0".equals(operator) ? "新增" : "1".equals(operator) ? "修改" : "2".equals(operator) ? "删除" : "还原");
//      setSaxElement(xsw, "行为时间", createTimeStr.toString());
//      setSaxElement(xsw, "行为依据");
//      setSaxElement(xsw, "行为描述");
//      xsw.writeEndElement();//业务实体
//      xsw.writeEndElement();//业务实体块
//      xsw.writeStartElement("机构人员实体块");
//      xsw.writeStartElement("机构人员实体");
//      setSaxElement(xsw, "机构人员标识符", archiveInfoJson.getOrganizationPersonId());
//      setSaxElement(xsw, "机构人员类型", String.valueOf(archiveInfoJson.getOrganizationType()));
//      setSaxElement(xsw, "机构人员名称", archiveInfoJson.getOrganizationUserName());
//      setSaxElement(xsw, "组织机构代码", archiveInfoJson.getOrganizationCode());
//      setSaxElement(xsw, "个人职位");
//      xsw.writeEndElement();///机构人员实体
//      xsw.writeStartElement("机构人员实体关系");
//      setSaxElement(xsw, "机构人员标识符", archiveInfoJson.getOrganizationPersonId());
//      setSaxElement(xsw, "被关联机构人员标识符");
//      setSaxElement(xsw, "关系类型");
//      setSaxElement(xsw, "关系");
//      setSaxElement(xsw, "关系描述");
//      xsw.writeEndElement();//机构人员实体关系
//      xsw.writeEndElement();//机构人员实体块
//      xsw.writeEndElement();//封装内容
//      xsw.writeEndElement();//被签名对象
//      xsw.writeEndElement();//电子文件封装包
//      xsw.writeEndDocument();//document
//      IOTool.closeQuietly(xsw);
//      //先生成到文件中去，再读取，才能生成加密，因为SAX不在内存中
//      Document document = new SAXReader().read(pathname);
//      //获取到xml内容,将要被加密的内容
//      String signContent = XmlTool.getContentByElement((Document) document.clone());
//      //进行加签认证
//      Map<String, String> signMap = Sm2Tool.encryptXml(signContent);
//      //公钥/签名结果/算法标识符 签名结果（M61）采用Base64进行编码。证书（M62）应采用Base64进行编码。
//      String publicKey = signMap.get("publicKey");
//      String siginKey = signMap.get("siginKey");
//      String algorithm = signMap.get("algorithm");
//      String signatureValue = signMap.get("signatureValue");
//      Element rss = document.getRootElement();
//      elecSignAndsyncSign(archiveInfoJson, rss, dateTime, publicKey, siginKey, algorithm);
//      //生成xml文件 动态设置xml名字
//      File file = new File(pathname);
//      OutputFormat format = OutputFormat.createPrettyPrint();
//      outPut(document, format, file);
//      archiveInfoJson.setFileSize(file.length());
//      archiveInfoJson.setMd5(MD5Tool.getMd5ByFileName(file));
//      return signCheck(signContent, publicKey, signatureValue);
//   }
//
//   /**
//    * 修改标识符
//    *
//    * @param archiveInfoJson 通用实体类
//    * @param tag             标识
//    */
//   private void tagNumber2(ArchiveInfoJson archiveInfoJson, Element tag) {
//      if (archiveInfoJson.getTagNumber() == null) {
//         tag.setText("1");
//      } else {
//         int i = Integer.parseInt(archiveInfoJson.getTagNumber());
//         tag.setText(String.valueOf(i));
//      }
//   }
//
//   /***
//    * 创建文件流，读取，输出，关闭
//    *
//    * @param document
//    * @param format
//    * @param file
//    */
//   private void outPut(Document document, OutputFormat format, File file) {
//      FileOutputStream out = null;
//      XmlWriter writer = null;
//      format.setEncoding("UTF-8");
//      logger.info("文件是否存在：" + file.exists());
//      try {
//         gcAndFinalize();
//         out = new FileOutputStream(file);
//         //设置standalone
//         writer = new XmlWriter(out, format);
//         //设置是否转义，默认使用转义字符
//         writer.setEscapeText(false);
//         writer.write(document);
//      } catch (Exception e) {
//         logger.error("文件被占用");
//      } finally {
//         IOTool.closeQuietly(writer);
//         IOTool.closeQuietly(out);
//      }
//   }
//
//   /***
//    * 生成sign
//    *
//    * @param asXML
//    * @param publicKey
//    * @param siginKey
//    * @return
//    */
//   private Result2Xml signCheck(String asXML, String publicKey, String siginKey) {
//      if (asXML != null) {
//         boolean unsignData = Sm2Tool.unsignData(asXML, publicKey, siginKey);
//         return Result2Xml.success(CommonCodeEnum.XML_SUCCESS);
//      } else {
//         return Result2Xml.success(CommonCodeEnum.XML_SUCCESS);
//      }
//   }
//
//   /***
//    * //电子签名块,证书块,锁定签名
//    *
//    * @param archiveInfoJson
//    * @param rss
//    * @param dateTime
//    * @param publicKey
//    * @param siginKey
//    * @param algorithm
//    */
//   private void elecSignAndsyncSign(ArchiveInfoJson archiveInfoJson, Element rss, String dateTime, String publicKey, String siginKey, String algorithm) {
//      Element electronicSignatureBlock = rss.addElement("电子签名块");
//      Element electronicSignature = electronicSignatureBlock.addElement("电子签名");
//      electronicSignature.addElement("签名标识符").setText(algorithm);
//      electronicSignature.addElement("签名规则").setText(algorithm);
//      electronicSignature.addElement("签名时间").setText(dateTime);
//      electronicSignature.addElement("签名人").setText(archiveInfoJson.getOrganizationUserName());
//      //签名结果（M61）采用Base64进行编码。
//      electronicSignature.addElement("签名结果").setText(siginKey);
//      //证书块
//      Element certificateOfBlock = electronicSignature.addElement("证书块");
//      //证书（M62）应采用Base64进行编码。
//      certificateOfBlock.addElement("证书").setText(publicKey);
//      certificateOfBlock.addElement("证书引用").setText(algorithm);
//      electronicSignature.addElement("签名算法标识").setText(algorithm);
//      //签名-加签认证
//      Element syncSign = rss.addElement("锁定签名");
//      syncSign.addElement("签名标识符").setText(algorithm);
//      syncSign.addElement("签名规则").setText(algorithm);
//      syncSign.addElement("签名时间").setText(dateTime);
//      syncSign.addElement("签名人").setText(archiveInfoJson.getOrganizationUserName());
//      syncSign.addElement("签名结果").setText(siginKey);
//      //证书块
//      Element certificateOfBlock2 = syncSign.addElement("证书块");
//      certificateOfBlock2.addElement("证书").setText(publicKey);
//      certificateOfBlock2.addElement("证书引用").setText(algorithm);
//      syncSign.addElement("签名算法标识").setText(algorithm);
//   }
//
//   private void signElement(XMLStreamWriter xsw) throws XMLStreamException {
//      xsw.writeStartElement("电子签名块");
//      xsw.writeStartElement("电子签名");
//      setSaxElement(xsw, "签名标识符", "-");
//      setSaxElement(xsw, "签名规则", "-");
//      setSaxElement(xsw, "签名时间", "-");
//      setSaxElement(xsw, "签名人", "-");
//      setSaxElement(xsw, "签名结果", "-");
//      setSaxElement(xsw, "证书块", "-");
//      setSaxElement(xsw, "签名算法标识", "-");
//      xsw.writeEndElement();//电子签名
//      xsw.writeEndElement();//电子签名块
//      xsw.writeStartElement("锁定签名");
//      setSaxElement(xsw, "被锁定签名标识符", "-");
//      setSaxElement(xsw, "签名规则", "-");
//      setSaxElement(xsw, "签名时间", "-");
//      setSaxElement(xsw, "签名人", "-");
//      setSaxElement(xsw, "签名结果", "-");
//      setSaxElement(xsw, "证书块", "-");
//      setSaxElement(xsw, "签名算法标识", "-");
//      xsw.writeEndElement();//锁定签名
//   }
//
//   private static void vehicleInformation(ArchiveInfoJson archiveInfoJson, XMLStreamWriter xsw) throws XMLStreamException {
//      for (XmlNodeAttribPojo xmlNodeAttrib : XmlPackageStructInfo.getInstnace().getStorageKeys()) {
//         PackageDataInfoPojo packageDataInfoPojo = archiveInfoJson.findPackageDataInfoByXmlAlias(xmlNodeAttrib.getName());
//         if (packageDataInfoPojo != null && !StringUtils.isEmpty(packageDataInfoPojo.getFieldValue())) {
//            setSaxElement(xsw, xmlNodeAttrib.getName(), packageDataInfoPojo.getFieldValue());
//         } else {
//            if (xmlNodeAttrib.isMandatory()) {
//               setSaxElement(xsw, xmlNodeAttrib.getName(), packageDataInfoPojo.getFieldValue());
//            }
//         }
//      }
//   }
//
//   private static void characteristic(ArchiveInfoJson archiveInfoJson, XMLStreamWriter xsw, LinkedHashMap map, LinkedHashMap activeMap, int size, boolean status) throws XMLStreamException {
//      final String documentTotal = "总册数";
//      final String[] CHARACTER_KEYS = new String[]{"页数", "语种", "稿本", "件数"};
//      for (String key : CHARACTER_KEYS) {
//         if (map.containsKey(key)) {
//            Object value = map.get(key);
//            setElementValue(xsw, key, key);
//            if (documentTotal.contains(key.toString())) {
//               setElementValue(xsw, key, "件数");
//            }
//         }
//      }
//      if (size <= 1 && archiveInfoJson.getTableName().contains("_document")) {
//         setSaxElement(xsw, "文件组合类型", "单件");
//      } else if (archiveInfoJson.getTableName().contains("_vol")) {
//         setSaxElement(xsw, "文件组合类型", "组合文件");
//      } else {
//         setSaxElement(xsw, "文件组合类型", "组合文件");
//      }
//      if (archiveInfoJson.getTableName().contains("_vol")) {
//         if (Objects.isNull(map.get("件数"))) {
//            setSaxElement(xsw, "件数", "" + size);
//         }
//         if (Objects.isNull(map.get("页数"))) {
//            Object pageTotal = activeMap.get("page_total");
//            if (!Objects.isNull(pageTotal)) {
//               setSaxElement(xsw, "页数", pageTotal.toString());
//            } else {
//               setSaxElement(xsw, "页数", "0");
//            }
//         }
//      }
//      if (Objects.isNull(map.get("语种"))) {
//         setSaxElement(xsw, "语种", "汉语");
//      }
//      if (Objects.isNull(map.get("稿本"))) {
//         if (status) {
//            setSaxElement(xsw, "稿本", "修订本");
//         } else {
//            setSaxElement(xsw, "稿本", "试行本");
//         }
//      }
//   }
//
//   private static void setElementValue(XMLStreamWriter xsw, String key, Object value) throws XMLStreamException {
//      if (value == null || "".equals(value)) {
//         setSaxElement(xsw, key);
//      } else {
//         setSaxElement(xsw, key, value.toString());
//      }
//   }
//
//   private static void originStart(ArchiveInfoJson archiveInfoJson, XMLStreamWriter xsw) throws XMLStreamException {
//      for (XmlNodeAttribPojo xmlNodeAttrib : XmlPackageStructInfo.getInstnace().getOriginStartKeys()) {
//         PackageDataInfoPojo packageDataInfoPojo = new PackageDataInfoPojo();
//         if (xmlNodeAttrib.getName().equals("全宗名称")) {
//            packageDataInfoPojo.setFieldType("varchar");
//            packageDataInfoPojo.setFieldValue(archiveInfoJson.getFondsName() != null ? archiveInfoJson.getFondsName() : "");
//         } else if (xmlNodeAttrib.getName().equals("立档单位名称")) {
//            packageDataInfoPojo.setFieldType("varchar");
//            packageDataInfoPojo.setFieldValue(StringUtils.isNotEmpty(archiveInfoJson.getCorpName()) ? archiveInfoJson.getCorpName() : "");
//         } else {
//            packageDataInfoPojo = archiveInfoJson.findPackageDataInfoByXmlAlias(xmlNodeAttrib.getName());
//         }
//         if (packageDataInfoPojo != null && !StringUtils.isEmpty(packageDataInfoPojo.getFieldValue())) {
//            setSaxElement(xsw, xmlNodeAttrib.getName(), packageDataInfoPojo.getFieldValue());
//         } else {
//            if (xmlNodeAttrib.isMandatory()) {
//               setSaxElement(xsw, xmlNodeAttrib.getName());
//            }
//         }
//      }
//   }
//
//   private static void partyNum(ArchiveInfoJson archiveInfoJson, XMLStreamWriter xsw) throws XMLStreamException {
//      for (XmlNodeAttribPojo xmlNodeAttrib : XmlPackageStructInfo.getInstnace().getArchiveCodeKeys()) {
//         PackageDataInfoPojo packageDataInfoPojo = null;
//         if (xmlNodeAttrib.getName().equals("室编件号")) {
//            packageDataInfoPojo = archiveInfoJson.findPackageDataInfoByFieldEn("document_code");
//         } else if (xmlNodeAttrib.getName().equals("室编案卷号")) {
//            packageDataInfoPojo = archiveInfoJson.findPackageDataInfoByFieldEn("vol_sequence");
//         } else if (xmlNodeAttrib.getName().equals("类别号")) {
//            packageDataInfoPojo = archiveInfoJson.findPackageDataInfoByFieldEn("classfy_code");
//         } else if (xmlNodeAttrib.getName().equals("机构或问题")) {
//            packageDataInfoPojo = archiveInfoJson.findPackageDataInfoByFieldEn("classfy_name");
//         } else {
//            packageDataInfoPojo = archiveInfoJson.findPackageDataInfoByXmlAlias(xmlNodeAttrib.getName());
//         }
//         if (packageDataInfoPojo != null && !StringUtils.isEmpty(packageDataInfoPojo.getFieldValue())) {
//            setSaxElement(xsw, xmlNodeAttrib.getName(), packageDataInfoPojo.getFieldValue());
//         } else {
//            if (xmlNodeAttrib.isMandatory()) {
//               setSaxElement(xsw, xmlNodeAttrib.getName());
//            }
//         }
//      }
//   }
//
//   private static void fileNumAndContentDes(ArchiveInfoJson archiveInfoJson, XMLStreamWriter xsw) {
//      //内容描述区块字段属性
//      List<String> contentKeys = XmlPackageStructInfo.getInstnace().getContentDesCriptionKeys().stream().map(t -> t.getName()).collect(Collectors.toList());
//      //档号及流水规则字段列表
//      List<String> archFieldList = new ArrayList<>();
//      //取档案库档号规则
//      if (archiveInfoJson.getArchiveCodeRule() != null & archiveInfoJson.getArchiveCodeRule().size() > 0) {
//         //过滤非字段内容
//         archFieldList = archiveInfoJson.getArchiveCodeRule().stream().filter(t -> t.startsWith("[")).map(t -> t.replace("[", "").replace("]", "")).collect(Collectors.toList());
//         //过滤逗号后的内容
//         archFieldList = archFieldList.stream().map(t -> t.indexOf(",") >= 0 ? t.substring(0, t.indexOf(",")) : t).collect(Collectors.toList());
//      }
//      //取档案库流水规则[分组字段，流水号补零长度]
//      TBaseSequenceRule tBaseSequenceRule = archiveInfoJson.getSequenceRule();
//      if (tBaseSequenceRule != null) {
//         String groupField = tBaseSequenceRule.getGroupField();
//         JSONArray jsonArray = JSON.parseArray(groupField);
//         if (jsonArray != null && jsonArray.size() > 0) {
//            for (Object jsonObject : jsonArray) {
//               archFieldList.add((String) ((JSONObject) jsonObject).get("fieldZnName"));
//            }
//         }
//      }
//      //取档案库封装标识字段
//      List<PackageDataInfoPojo> packageDataInfoPojoList = archiveInfoJson.findPackageDataInfoByIsXML(true);
//      if (packageDataInfoPojoList != null && packageDataInfoPojoList.size() > 0) {
//         archFieldList = packageDataInfoPojoList.stream().map(t -> t.getXmlAlias()).collect(Collectors.toList());
//      }
//      //合并字段列表形成内容描述内容列表
//      for (String fieldName : archFieldList) {
//         if (!contentKeys.contains(fieldName)) {
//            contentKeys.add(fieldName);
//         }
//      }
//      //填充内容描述区块
//      try {
//         for (String fieldName : contentKeys) {
//            XmlNodeAttribPojo xmlNodeAttrib = XmlPackageStructInfo.getInstnace().getContentDesCriptionKeys().stream().filter(t -> t.getName().equals(fieldName)).findFirst().orElse(null);
//            PackageDataInfoPojo packageDataInfoPojo = archiveInfoJson.findPackageDataInfoByXmlAlias(fieldName);
//            if (packageDataInfoPojo != null && !StringUtils.isEmpty(packageDataInfoPojo.getFieldValue())) {
//               setSaxElement(xsw, fieldName, packageDataInfoPojo.getFieldValue());
//            } else {
//               if (xmlNodeAttrib != null && xmlNodeAttrib.isMandatory()) {
//                  setSaxElement(xsw, xmlNodeAttrib.getName());
//               }
//            }
//         }
//      } catch (Exception ex) {
//         logger.error(ex.toString());
//         ex.printStackTrace();
//      }
//   }
//
//   private static void setSaxElement(XMLStreamWriter xsw, String localName, String content) throws XMLStreamException {
//      xsw.writeStartElement(localName);
//      xsw.writeCharacters(content);
//      xsw.writeEndElement();
//   }
//
//   private static void setSaxElement(XMLStreamWriter xsw, String localName) throws XMLStreamException {
//      xsw.writeStartElement(localName);
//      xsw.writeEndElement();
//   }
//
//   /***
//    * 更新xml
//    *
//    * @param archiveInfoJson
//    * @param document
//    * @param electronicRecords
//    * @return
//    */
//   private Result2Xml setOldXml(ArchiveInfoJson archiveInfoJson, Document document, List<LinkedHashMap> electronicRecords) {
//      LinkedHashMap activeMap = archiveInfoJson.getActiveMap();
//      String archiveId = archiveInfoJson.getArchiveId();
//      String archivesId = archiveInfoJson.getArchivesId();
//      String tableId = archiveInfoJson.getTableId();
//      Integer edit;
//      //i == 2//归档库-有修改则为修订包//修订包-判断document是否含有修改内容
//      Element root = document.getRootElement();
//      Element originRoot = (Element) root.clone();
//      Element nrms = root.element("被签名对象");
//      Element signElement = root.element("电子签名块");
//      //获取原修改标识符
//      String editTagContentType = nrms.element("封装包类型").getText();
//      int editTag = 0;
//      boolean s = false;
//      try {
//         editTag = Integer.parseInt(nrms.element("修改封装内容").element("修改标识符").getText());
//      } catch (Exception e) {
//         logger.warn("已经生成过XML，但未作出修改");
//         editTag = 0;
//         s = true;
//      }
//      //如果修改标识符和修改封装内容都不为空,或者修改类型为修改型
//      List<Element> elements;
//      List<Element> elementsList;
//      if ("修改型".equals(editTagContentType)) {
//         //即为修改两次或两次以上
//         elements = nrms.element("修改封装内容").element("修订内容").element("文件实体块").element("文件数据").elements("文档");
//         elementsList = elements;
//         edit = 2;
//         Element orgPackge = nrms.element("修改封装内容").element("原封装包");
//         //删除原来的原始封装包内容
//         orgPackge.remove(orgPackge.element("被签名对象"));
//         Element clone = (Element) originRoot.element("被签名对象").clone();
//         orgPackge.add(clone);
//         Element editCon = nrms.element("修改封装内容");
//         Element editCon2 = nrms.element("修改封装内容").element("修订内容");
//         //删除原来的修订内容
//         editCon.remove(editCon2);
//         Element orgEleSign = originRoot.element("电子签名块");
//         Element orgEleSignOld = orgPackge.element("电子签名块");
//         //删除原来的电子签名块，更换为上一次的修改型的电子签名块
//         orgPackge.remove(orgEleSignOld);
//         Element cloneSign = (Element) orgEleSign.clone();
//         orgPackge.add(cloneSign);
//      } else {
//         edit = 1;
//         editTag = 1;
//         elements = nrms.element("封装内容").element("文件实体块").element("文件数据").elements("文档");
//         elementsList = elements;
//      }
//      Object docNumber = activeMap.get("docnumber");
//      docNumber = Objects.isNull(docNumber) ? "" : docNumber;
//      //修改为 operatType=1 根据主键查询日志信息
//      Map hash = tBaseArchivesHashMapper.findByIdAndOperatType(archiveId, "1");
//      archiveInfoJson.setHash(hash);
//      //设置电子文件号，文件编号，文档标识符，修改标识符，xml名字
//      setArchAndDocNumAndTagNum(archiveInfoJson, editTag, docNumber, archiveId, true, s);
//      //将原始的封装包内容传入修订xml方法中
//      Result2Xml result = createNewXml(elementsList, document, originRoot, archiveInfoJson, electronicRecords, true, nrms, signElement, edit);
//      if (result.isFlag()) {
//         String xmlFileId = archiveInfoJson.getXmlFileId();
//         //创建成功后还需要向XML表里面插入一条新的数据
//         setLogger(saveXml(xmlFileId, archiveId, tableId, archiveInfoJson, archivesId));
//      }
//      runTime(archiveInfoJson.getStart());
//      return result;
//   }
//
//   /***
//    * 循环创建电子文件部分element
//    *
//    * @param elementsList
//    * @param archiveInfoJson
//    * @param electronicRecords
//    * @param status
//    * @param activeMap
//    * @param size
//    * @param fileData
//    * @param xmlFileId
//    * @return
//    */
//   private boolean forEletronic(XMLStreamWriter xsw, List<Element> elementsList, ArchiveInfoJson archiveInfoJson,
//                                List<LinkedHashMap> electronicRecords, boolean status, LinkedHashMap activeMap,
//                                int size, String xmlFileId, Element originRoot) throws Exception {
//      if (size != 0) {
//         int i = 1;
//         //给查询的结果按照序号进行排序
//         SortUtils.sort(electronicRecords, "list_order", true);
//         for (Map electronicRecord : electronicRecords) {
//            String downLoadPath = fileConfig.getFileSaveRootPath("", electronicRecord.get("path_status").toString());
//            String filePath = electronicRecord.get("filepath").toString();
//            File file = new File(downLoadPath + filePath);
//            String md5Code = null;
//            try {
//               md5Code = MD5Tool.getMd5ByFileName(file);
//            } catch (Exception e) {
//               e.printStackTrace();
//               continue;
//            }
//            boolean elfmd5Flag = electronicRecord.get("elfmd5").equals(md5Code);
//            if (!elfmd5Flag) {
//               //如果数据发生变更则为非法修改
//               continue;
//            }
//            String uuId = IDTool.uuid2();
//            String uuId2 = IDTool.uuid2();
//            String uuId3 = IDTool.uuid2();
//            TBaseElectronicRecord tBaseElectronicRecord = new TBaseElectronicRecord();
//            xsw.writeStartElement("文档");
//            setSaxElement(xsw, "文档标识符", size > 0 ? "" + archiveInfoJson.getTagNumber() + i : "01");
//            setSaxElement(xsw, "文档序号", String.valueOf(i));
//            //主文主从声明
//            Object elfclass = "附属文档";
//            Object obj = electronicRecord.get("elfclass");
//            if (!Objects.isNull(obj)) {
//               if (StringUtils.isEmpty(elfclass.toString()) || elfclass.toString().trim().length() == 0) {
//                  elfclass = obj;
//               }
//            }
//            setSaxElement(xsw, "文档主从声明", elfclass.toString());
//            setSaxElement(xsw, "题名", archiveInfoJson.getTitle());
//            xsw.writeStartElement("文档数据");
//            //电子文件ID
//            String id = electronicRecord.get("id").toString();
//            Element code = null;
//            Element element = null;
//            boolean equals = false;
//            String oldBase64Id = null;
//            //elementsList 找到上次和当前主键ID相同的引用编码数据ID 一直追溯到编码数据ID的终点（直到没有引用数据ID为止）
//            if (elementsList != null && elementsList.size() != 0) {
//               for (Element m : elementsList) {
//                  Element dataBase = m.element("文档数据").element("编码数据");
//                  Attribute ref = dataBase.attribute("引用编码数据ID");
//                  if (!Objects.isNull(ref)) {
//                     String oldId = ref.getValue();
//                     equals = oldId.equals(id);
//                     if (equals) {
//                        element = m;
//                        oldBase64Id = id;
//                        break;
//                     }
//                  }
//                  if (!equals) {
//                     String oldId = dataBase.attribute("编码数据ID").getValue();
//                     equals = oldId.equals(id);
//                     if (equals) {
//                        element = m;
//                        oldBase64Id = id;
//                        break;
//                     }
//                  }
//               }
//               if (!equals) {
//                  Element entry = originRoot.element("被签名对象");
//                  if (!Objects.isNull(entry)) {
//                     Element editContent = entry.element("修改封装内容");
//                     if (!Objects.isNull(editContent)) {
//                        Element oldPack = editContent.element("原封装包");
//                        if (!Objects.isNull(oldPack)) {
//                           element = XmlTool.readDocument(oldPack, id);
//                        }
//                     } else {
//                        element = XmlTool.readDocument(originRoot, id);
//                     }
//                  }
//               }
//            }
//            xsw.writeAttribute("文档数据ID", uuId);
//            xsw.writeStartElement("编码");
//            xsw.writeAttribute("编码ID", uuId2);
//
//            xsw.writeStartElement("电子属性");
//            electronicProperties(xsw, electronicRecord, null);
//            xsw.writeEndElement();//电子属性
//
//            xsw.writeStartElement("数字化属性");
//            setSaxElement(xsw, "数字化对象形态");
//            setSaxElement(xsw, "扫描分辨率");
//            setSaxElement(xsw, "扫描色彩模式");
//            setSaxElement(xsw, "图像压缩方案");
//            xsw.writeEndElement();//数字化属性
//            setSaxElement(xsw, "编码描述", "本封装包中“编码数据”元素存储的是计算机文件二进制流的 Base64 编码，有关 Base64 编码规则参见 IETF RFC 2045 多用途邮件扩展（MIME）第一部分：互联网信息体格式。当提取和显现封装在编码数据元素中的计算机文件时，应对 Base64 编码进行反编码，并依据封装包中“反编码关键字”元素中记录的值还原计算机文件的扩展名");
//            String extension = electronicRecord.get("extension").toString();
//            setSaxElement(xsw, "反编码关键字", "base64-" + extension);
//            xsw.writeStartElement("编码数据");
//            //可以引用
//            boolean flag = false;
//            if (!status) {
//               //原始封装包
//               xsw.writeAttribute("编码数据ID", id);
//               archiveInfoJson.setMd5FileId(id);
//            } else {
//               //修改类型，未变更则用电子文件ID
//               xsw.writeAttribute("编码数据ID", uuId3);
//               archiveInfoJson.setMd5FileId(uuId3);
//               if (!Objects.isNull(element)) {
//                  flag = true;
//               } else {
//                  xsw.writeAttribute("编码数据ID", id);
//                  archiveInfoJson.setMd5FileId(id);
//               }
//            }
//            //封装包ID
//            archiveInfoJson.setXmlFileId(xmlFileId);
//            if (StringUtils.isNotEmpty(oldBase64Id)) {
//               xsw.writeAttribute("引用编码数据ID", oldBase64Id);
//            } else {
//               if (flag) {
//                  //引用数据不为空，设置引用数据ID
//                  xsw.writeAttribute("引用编码数据ID", id);
//               } else {
//                  //引用数据为空，设置编码数据内容 base64
//                  Reader reader = null;
//                  try {
//                     reader = new InputStreamReader(new Base64InputStream(new FileInputStream(file), true, -1, null));
//                     char[] buf = new char[4096];
//                     int n;
//                     while ((n = reader.read(buf)) >= 0) {
//                        xsw.writeCharacters(buf, 0, n);
//                     }
//                     xsw.writeEndElement();
//                     xsw.writeEndDocument();
//                     xsw.flush();
//                  } catch (Exception e) {
//                     e.printStackTrace();
//                  } finally {
//                     IOTool.closeQuietly(reader);
//                  }
//               }
//            }
//            xsw.writeEndElement();//编码数据
//            xsw.writeEndElement();//编码
//            xsw.writeEndElement();//文档数据
//            xsw.writeEndElement();//文档
//            tBaseElectronicRecord.setId(id);
//            tBaseElectronicRecord.setPackageId(xmlFileId);
//            tBaseElectronicRecord.setDocCodeId(archiveInfoJson.getMd5FileId());
//            tBaseElectronicRecordMapper.updateById(tBaseElectronicRecord);
//            i++;
//         }
//      } else {
//         //封装包ID
//         archiveInfoJson.setXmlFileId(xmlFileId);
//      }
//      return false;
//   }
//
//   /***
//    * 如果为案卷
//    *
//    * @param elementsList
//    * @param originRoot
//    * @param archiveInfoJson
//    * @param status
//    * @param activeMap
//    * @param fileData
//    * @param xmlFileId
//    * @param archiveId
//    * @return
//    */
//   private boolean forDocuments(XMLStreamWriter xsw,List<Element> elementsList, Element originRoot,
//                                ArchiveInfoJson archiveInfoJson, boolean status, LinkedHashMap activeMap,
//                                String xmlFileId, String archiveId) throws Exception{
//      Object documentTotal = activeMap.get("document_total");
//      if (!Objects.isNull(documentTotal)) {
//         int total = Integer.parseInt(documentTotal.toString());
//         if (total != 0) {
//            String volTableName = archiveInfoJson.getTableName();
//            List<LinkedHashMap> vol2DocMap = null;
//            try {
//               vol2DocMap = tBaseArchTableMapper.selectDocByTableNameAndVolId(volTableName.replace("_vol", "_document"), archiveId);
//            } catch (Exception e) {
//               e.printStackTrace();
//               return true;
//            }
//            if (vol2DocMap.size() != 0 && vol2DocMap.size() == total) {
//               int i = 1;
//               for (LinkedHashMap vol2Doc : vol2DocMap) {
//                  Object vol2DocId = vol2Doc.get("id");
//                  if (vol2DocId != null) {
//                     //只处理已经生成了xml的文件档案
//                     if (packageFileMapper.checkExistByArchIdAndStatus(vol2DocId.toString()) == 1) {
//                        Map xmlContent = packageFileMapper.findAllByArchId(vol2DocId.toString());
//                        String path2Xml = xmlContent.get("filepath").toString();
//                        String id = xmlContent.get("id").toString();
//                        String md5Check = xmlContent.get("md5").toString();
//                        String statusT = xmlContent.get("path_status").toString();
//                        String downLoadPath = fileConfig.getFileSaveRootPath("", statusT);
//                        File file = new File(downLoadPath + path2Xml);
//                        String md5Code = null;
//                        try {
//                           md5Code = MD5Tool.getMd5ByFileName(file);
//                        } catch (Exception e) {
//                           e.printStackTrace();
//                           logger.error(CommonCodeEnum.XML_ERROR.getMessage());
//                           continue;
//                        }
//                        boolean elfmd5Flag = md5Check.equals(md5Code);
//                        if (!elfmd5Flag) {
//                           //如果数据发生变更则为非法修改
//                           logger.error(CommonCodeEnum.ILLEGAL_MODIFICATION.getMessage());
//                           continue;
//                        }
//                        xsw.writeStartElement("文档");
//                        setSaxElement(xsw, "文档标识符", total > 0 ? "" + archiveInfoJson.getTagNumber() + i : "01");
//                        setSaxElement(xsw, "文档序号", String.valueOf(i));
//                        setSaxElement(xsw, "文档主从声明", "附属文档");
//                        setSaxElement(xsw, "题名", archiveInfoJson.getTitle());
//                        xsw.writeStartElement("文档数据");
//                        String uuId = IDTool.uuid2();
//                        String uuId2 = IDTool.uuid2();
//                        String uuId3 = IDTool.uuid2();
//                        Element code = null;
//                        Element element = null;
//                        boolean equals = false;
//                        String oldBase64Id = null;
//                        //elementsList 找到上次和当前主键ID相同的引用编码数据ID 一直追溯到编码数据ID的终点（直到没有引用数据ID为止）
//                        if (elementsList != null && elementsList.size() != 0) {
//                           for (Element m : elementsList) {
//                              Element dataBase = m.element("文档数据").element("编码数据");
//                              Attribute ref = dataBase.attribute("引用编码数据ID");
//                              if (!Objects.isNull(ref)) {
//                                 String oldId = ref.getValue();
//                                 equals = oldId.equals(id);
//                                 if (equals) {
//                                    element = m;
//                                    oldBase64Id = id;
//                                    break;
//                                 }
//                              }
//                              if (!equals) {
//                                 String oldId = dataBase.attribute("编码数据ID").getValue();
//                                 equals = oldId.equals(id);
//                                 if (equals) {
//                                    element = m;
//                                    oldBase64Id = id;
//                                    break;
//                                 }
//                              }
//                           }
//                           if (!equals) {
//                              Element entry = originRoot.element("被签名对象");
//                              if (!Objects.isNull(entry)) {
//                                 Element editContent = entry.element("修改封装内容");
//                                 if (!Objects.isNull(editContent)) {
//                                    Element oldPack = editContent.element("原封装包");
//                                    if (!Objects.isNull(oldPack)) {
//                                       element = XmlTool.readDocument(oldPack, id);
//                                    }
//                                 } else {
//                                    element = XmlTool.readDocument(originRoot, id);
//                                 }
//                              }
//                           }
//                        }
//                        xsw.writeAttribute("文档数据ID", uuId);
//                        xsw.writeStartElement("编码");
//                        xsw.writeAttribute("编码ID", uuId2);
//
//                        xsw.writeStartElement("电子属性");
//                        electronicProperties(xsw, null, xmlContent);
//                        xsw.writeEndElement();//电子属性
//
//                        xsw.writeStartElement("数字化属性");
//                        setSaxElement(xsw, "数字化对象形态");
//                        setSaxElement(xsw, "扫描分辨率");
//                        setSaxElement(xsw, "扫描色彩模式");
//                        setSaxElement(xsw, "图像压缩方案");
//                        xsw.writeEndElement();//数字化属性
//                        setSaxElement(xsw, "编码描述", "本封装包中“编码数据”元素存储的是计算机文件二进制流的 Base64 编码，有关 Base64 编码规则参见 IETF RFC 2045 多用途邮件扩展（MIME）第一部分：互联网信息体格式。当提取和显现封装在编码数据元素中的计算机文件时，应对 Base64 编码进行反编码，并依据封装包中“反编码关键字”元素中记录的值还原计算机文件的扩展名");
//                        setSaxElement(xsw, "反编码关键字", "base64-eep");
//                        xsw.writeStartElement("编码数据");
//                        //可以引用
//                        boolean flag = false;
//                        if (!status) {
//                           //原始封装包
//                           xsw.writeAttribute("编码数据ID", id);
//                           archiveInfoJson.setMd5FileId(id);
//                        } else {
//                           //修改类型，未变更则用电子文件ID
//                           xsw.writeAttribute("编码数据ID", uuId3);
//                           archiveInfoJson.setMd5FileId(uuId3);
//                           if (!Objects.isNull(element)) {
//                              flag = true;
//                           } else {
//                              xsw.writeAttribute("编码数据ID", id);
//                              archiveInfoJson.setMd5FileId(id);
//                           }
//                        }
//                        //封装包ID
//                        archiveInfoJson.setXmlFileId(xmlFileId);
//                        if (StringUtils.isNotEmpty(oldBase64Id)) {
//                           xsw.writeAttribute("引用编码数据ID", oldBase64Id);
//                        } else {
//                           if (flag) {
//                              //引用数据不为空，设置引用数据ID
//                              xsw.writeAttribute("引用编码数据ID", id);
//                           } else {
//                              //引用数据为空，设置编码数据内容 base64
//                              try {
//                                 byte[] bytes = XmlTool.getContentByFile(file).getBytes("utf-8");
//                                 String dest = Base64Utils.encode(bytes);
//                                 logger.info("编码数据的base64编码长度为:" + dest.length());
//                                 xsw.writeCharacters(dest);
//                                 xsw.flush();
//                              } catch (Exception e) {
//                                 e.printStackTrace();
//                              }
//                           }
//                        }
//                     } else {
//                        //案卷下的文件未生成XML
//                        continue;
//                     }
//                  }
//                  i++;
//               }
//               if (i == 1) {
//                  //案卷下的文件都没有生成未生成XML
//                  logger.info(CommonCodeEnum.XML_DOC_NOT_EXIST.getMessage());
//               }
//            }
//         }
//      }
//      if (StringUtils.isEmpty(archiveInfoJson.getXmlFileId())) {
//         //封装包ID
//         archiveInfoJson.setXmlFileId(xmlFileId);
//      }
//      return false;
//   }
//
//   /***
//    * 电子属性
//    * @param electronicRecord     电子文件map
//    * @param electronicProperties 属性
//    */
//   private void electronicProperties(XMLStreamWriter xsw, Map electronicRecord, Map xmlContent) throws Exception {
//      try {
//         Properties properties = new Properties();
//         properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("format_desc.properties"));
//         if (electronicRecord != null) {
//            String extension = electronicRecord.get("extension").toString();
//            setFormat(xsw, properties, extension);
//            setComputerName(xsw, electronicRecord);
//            setComputerSize(xsw, electronicRecord);
//         } else {
//            setFormat(xsw, properties, "xml");
//            setComputerName(xsw, xmlContent);
//            setComputerSize(xsw, xmlContent);
//         }
//      } catch (IOException e) {
//         logger.error(this.getClass().getName() + "读取properties文件失败");
//         e.printStackTrace();
//      }
//   }
//
//   private void setComputerSize(XMLStreamWriter xsw, Map electronicRecord) throws XMLStreamException {
//      if (electronicRecord.get("filesize") == null) {
//         setSaxElement(xsw, "计算机文件大小");
//      } else {
//         setSaxElement(xsw, "计算机文件大小", electronicRecord.get("filesize").toString());
//      }
//      setSaxElement(xsw, "文档创建程序", "");
//   }
//
//   private void setComputerName(XMLStreamWriter xsw, Map electronicRecord) throws XMLStreamException {
//      if (electronicRecord.get("filepath") == null) {
//         setSaxElement(xsw, "计算机文件名");
//      } else {
//         String saveFilepPath = electronicRecord.get("savefilename").toString();
//         setSaxElement(xsw, "计算机文件名", saveFilepPath);
//      }
//   }
//
//   private void setFormat(XMLStreamWriter xsw, Properties properties, String extension) throws XMLStreamException {
//      for (String s : decodeStr) {
//         if (extension.contains(s) || extension.equalsIgnoreCase(s)) {
//            setSaxElement(xsw, "格式信息", extension + properties.getProperty(s));
//            break;
//         }
//      }
//   }
//
//   /***
//    * 路径生成
//    * 设置并保存xml
//    *
//    * @param archiveInfoJson
//    * @param activeMap
//    * @param archiveId
//    * @return
//    * @throws IOException
//    */
//   private String setAndSaveXml(ArchiveInfoJson archiveInfoJson, LinkedHashMap activeMap, String archiveId) throws IOException {
//      Calendar now = Calendar.getInstance();
//      int year = now.get(Calendar.YEAR);
//      int month = now.get(Calendar.MONTH) + 1;
//      int day = now.get(Calendar.DAY_OF_MONTH);
//      StringBuffer buffer = new StringBuffer();
//      //表名/年/月/日/档案数据ID/ 目录
//      //表名/年/月/日/档案数据ID/时间戳.eep 文件
//      String pathDir = null;
//      String xmlPath = null;
//      String xmlFilePathPriFix = null;
//      //查询原来位置，如果没有原来位置就新生成
//      if (packageFileMapper.checkExistByArchId(archiveId) == 1) {
//         TBasePackagefile tBasePackagefile = packageFileMapper.findAll2ObjByArchId(archiveId);
//         xmlFilePathPriFix = fileConfig.getFileSaveRootPath("", String.valueOf(tBasePackagefile.getPathStatus()));
//         xmlPath = packageFileMapper.findFilePathByArchId(archiveId);
//         pathDir = xmlPath.substring(0, xmlPath.lastIndexOf("/")) + "/";
//      } else {
//         //全部默认收集整编库，按照默认的方式（年月日）进行存储
//         xmlFilePathPriFix = fileConfig.getElectronic();
//         pathDir = buffer.append(archiveInfoJson.getTableName()).append("/").append(year).append("/").
//                 append(month).append("/").append(day).append("/").append(archiveId).append("/").toString();
//         xmlPath = pathDir + System.currentTimeMillis() + ".eep";
//      }
//      //文件夹不存在,自动创建文件目录
//      File folder = new File(xmlFilePathPriFix + pathDir);
//      if (!folder.exists() && !folder.isDirectory()) {
//         folder.mkdirs();
//      }
//      //文件不存在,自动创建文件
//      String pathname = xmlFilePathPriFix + xmlPath;
//      logger.info("xml生成地址：" + pathname);
//      File file = new File(pathname);
//      if (!file.exists()) {
//         file.createNewFile();
//      }
//      archiveInfoJson.setFilePath(xmlPath);
//      archiveInfoJson.setFilePathAll(pathname);
//      archiveInfoJson.setSaveName(file.getName());
//      return pathname;
//   }
//
//   /**
//    * 主方法main
//    * 根据档案类型封装数据包
//    *
//    * @param tableId   各个档案库所拥有的表（t_base_arch_table）档案id
//    * @param archiveId 比如 f1_37_document 动态表id
//    * @return {@link Result2Xml}
//    * @email 1793327033@qq.com
//    * @classname XmlDataPackgeUtils
//    * @author: osc_lihonglin
//    * @date: 2021/7/2 22:30
//    */
//   @Transactional(rollbackFor = Exception.class)
//   @ApiOperation(value = "根据档案类型封装数据包")
//   @SuppressWarnings({"AlibabaMethodTooLong", "all"})
//   public Result2Xml fileXml(String archiveId, String tableId) {
//      if (StringUtils.isEmpty(archiveId) || StringUtils.isEmpty(tableId)) {
//         logger.error(CommonCodeEnum.PARAM_REQUIRE.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.PARAM_REQUIRE);
//      }
//      long start = System.currentTimeMillis();
//      //false/0原始包 true/1修订包
//      boolean status = false;
//      //修改次数,0即为一次都没修改 2修改过一次或多次以上
//      Integer edit = 0;
//      int number = -1;
//      //文档标识符：RD 修改 R-文档 D。
//      //其中“R”为 EEP 修改次数，原始 EEP 的 R 值为 0,EEP每修改一次，R 的值增加 1。
//      //当文件组合类型（M41）的值为“单件”时，“D”的值为 1；
//      //当文件组合类型（M41）的值为“组合文件”时，“D”用文档序号（M19） 文档序号表示。
//      fileConfig = SpringBeanFactoryUtils.getBean(FileConfig.class);
//      xmlService = SpringBeanFactoryUtils.getBean(XmlService.class);
//      tabFieldMapper = SpringBeanFactoryUtils.getBean(TBaseTabFieldMapper.class);
//      packageFileMapper = SpringBeanFactoryUtils.getBean(TBasePackageFileMapper.class);
//      tSyslogOperateMapper = SpringBeanFactoryUtils.getBean(TSyslogOperateMapper.class);
//      tBaseArchivesHashMapper = SpringBeanFactoryUtils.getBean(TBaseArchivesHashMapper.class);
//      tBaseArchTableMapper = (TBaseArchTableMapper) SpringBeanFactoryUtils.getBean("TBaseArchTableMapper");
//      tBaseElectronicRecordMapper = (TBaseElectronicRecordMapper) SpringBeanFactoryUtils.getBean("TBaseElectronicRecordMapper");
//      //t_base_arch_table根据前端传过来的id查询所对应的表名
//      int checkArchTableCount = tBaseArchTableMapper.checkFindById(tableId);
//      if (checkArchTableCount == 0) {
//         logger.error(CommonCodeEnum.GET_OBJ_NULL_ERROR.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.GET_OBJ_NULL_ERROR);
//      }
//      TBaseArchTable tBaseArchTable = tBaseArchTableMapper.findById(tableId);
//      //t_base_arch_table表内容必须存在
//      if (Objects.isNull(tBaseArchTable)) {
//         logger.error(CommonCodeEnum.GET_OBJ_NULL_ERROR.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.GET_OBJ_NULL_ERROR);
//      }
//      //档案库id必须存在
//      if (StringUtils.isEmpty(tBaseArchTable.getArchivesId())) {
//         logger.error(CommonCodeEnum.PARAM_REQUIRE.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.PARAM_REQUIRE);
//      }
//      //获取到该id所对应的表名
//      String tableName = tBaseArchTable.getTableName();
//      int checkArchiveDataCount = tBaseArchTableMapper.checkAllByTableName(tableName, archiveId);
//      if (checkArchiveDataCount == 0) {
//         logger.error(CommonCodeEnum.GET_OBJ_NULL_ERROR.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.GET_OBJ_NULL_ERROR);
//      }
//      //动态表根据表名查询到该表的所有信息列表 包含字段以及内容 内容描述 f1_37_document//解析前的map
//      LinkedHashMap activeMap = tBaseArchTableMapper.selectAllByTableName(tableName, archiveId);
//      //档号和动态表不能为空，否则不能生成xml
//      if (Objects.isNull(activeMap)) {
//         logger.error(CommonCodeEnum.XML_DATA_NOT_EXIST.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.XML_DATA_NOT_EXIST);
//      }
//      if (Objects.isNull(activeMap.get("arch_code")) || "".equals(activeMap.get("arch_code"))) {
//         logger.error(CommonCodeEnum.XML_ARCH_CODE_ERROR.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.XML_ARCH_CODE_ERROR);
//      }
//      //电子文件号(档案ID)必有项
//      if (Objects.isNull(activeMap.get("id"))) {
//         logger.error(CommonCodeEnum.ELECTRONIC_RECORD_NULL.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.ELECTRONIC_RECORD_NULL);
//      }
//      //动态表的解析-根据英文字段查询中文字段//解析后的map
//      LinkedHashMap map = activeMapParse(activeMap, tableId);
//      //解析后为空
//      if (Objects.isNull(map)) {
//         logger.error(CommonCodeEnum.ARCHIVE_PARSE_ERROR.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.ARCHIVE_PARSE_ERROR);
//      }
//      //如果status为true则为修订包//根据table_name,table_id,archive_id查询电子文件表列表
//      List<LinkedHashMap> electronicRecords = null;
//      try {
//         electronicRecords = tBaseArchTableMapper.findElectronicRecord(tableId, tableName, archiveId);
//      } catch (Exception e) {
//         e.printStackTrace();
//         logger.error(CommonCodeEnum.GET_OBJ_NULL_ERROR.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.GET_OBJ_NULL_ERROR);
//      }
//      //如果从路径拿不到文件就新增
//      int count = packageFileMapper.checkExistByArchId(archiveId);
//      if (count > 1) {
//         logger.error(CommonCodeEnum.XML_RESULT_ERROR.getMessage());
//         return Result2Xml.failed(CommonCodeEnum.XML_RESULT_ERROR);
//      }
//      Object shouJiOrGuiDang = activeMap.get("status");
//      int i = 1;
//      if (!Objects.isNull(shouJiOrGuiDang)) {
//         i = Integer.parseInt(shouJiOrGuiDang.toString());
//      }
//      //通用实体类对象//设置通用属性
//      ArchiveInfoJson archiveInfoJson = new ArchiveInfoJson();
//      archiveInfoJson.setMap(map);
//      archiveInfoJson.setStart(start);
//      archiveInfoJson.setTableId(tableId);
//      archiveInfoJson.setActiveMap(activeMap);
//      archiveInfoJson.setArchiveId(archiveId);
//      archiveInfoJson.setTableName(tableName);
//      archiveInfoJson.setArchivesId(tBaseArchTable.getArchivesId());
//      archiveInfoJson.setTableDisplayName(tBaseArchTable.getTableDisplayName());
//      //全宗号//全宗名//立档单位名称-公司名称//公司的id
//      TBaseFonds fonds = tBaseArchTable.getBaseFonds();
//      archiveInfoJson.setFondsId(fonds.getId());
//      archiveInfoJson.setCorpId(fonds.getCorpId());
//      archiveInfoJson.setFondsCode(fonds.getFondsCode());
//      archiveInfoJson.setFondsName(fonds.getFondsName());
//      //组织机构名称//机构人员类型//组织机构编码
//      Organization organization = fonds.getOrganization();
//      archiveInfoJson.setArchCode(activeMap.get("id").toString());
//      archiveInfoJson.setSecurity(Objects.isNull(activeMap.get("security")) ? "" : activeMap.get("security").toString());
//      archiveInfoJson.setOrganizationName(Objects.isNull(organization) ? fonds.getFondsName() : organization.getName());
//      archiveInfoJson.setOrganizationType(Objects.isNull(organization) ? "单位" : String.valueOf(organization.getType()));
//      archiveInfoJson.setOrganizationCode(Objects.isNull(organization) ? fonds.getFondsCode() : organization.getCode());
//      archiveInfoJson.setOrganizationPersonId(Objects.isNull(activeMap.get("creater_id")) ? "" : activeMap.get("creater_id").toString());
//      archiveInfoJson.setOrganizationUserName(Objects.isNull(activeMap.get("creatername")) ? "" : activeMap.get("creatername").toString());
//      //如果status为false则为原始包//i == 1 收集整编-始终都是原始包
//      if ((count == 0 && (i == 1 || i == 2)) || (count == 1 && i == 1)) {
//         return setNewXml(archiveInfoJson, edit, electronicRecords);
//      } else if (count == 1 && i == 2) {
//         Document document = checkReadXmlRuleByDocument(archiveId);
//         if (!Objects.isNull(document)) {
//            return setOldXml(archiveInfoJson, document, electronicRecords);
//         } else {
//            return setNewXml(archiveInfoJson, edit, electronicRecords);
//         }
//      }
//      return Result2Xml.success(CommonCodeEnum.SUCCESS);
//   }
//
//   /***
//    * 创建xml
//    *
//    * @param archiveInfoJson
//    * @param edit
//    * @param electronicRecords
//    * @return
//    */
//   private Result2Xml setNewXml(ArchiveInfoJson archiveInfoJson, Integer edit, List<LinkedHashMap> electronicRecords) {
//      LinkedHashMap activeMap = archiveInfoJson.getActiveMap();
//      Object docNumber = activeMap.get("docnumber");
//      docNumber = Objects.isNull(docNumber) ? "" : docNumber;
//      archiveInfoJson.setListOrder("01");
//      String archiveId = archiveInfoJson.getArchiveId();
//      String archivesId = archiveInfoJson.getArchivesId();
//      String tableId = archiveInfoJson.getTableId();
//      //新增 operatType=0 根据主键查询日志信息
//      Map hash = tBaseArchivesHashMapper.findByIdAndOperatType(archiveId, "0");
//      //设置电子文件号，文件编号，文档标识符，修改标识符，xml名字
//      setArchAndDocNumAndTagNum(archiveInfoJson, 0, docNumber, archiveId, false, false);
//      //创建xml
//      Result2Xml result = createNewXml(null, null, null, archiveInfoJson, electronicRecords, false,
//              null, null, edit);
//      if (result.isFlag()) {
//         String xmlFileId = archiveInfoJson.getXmlFileId();
//         //创建成功后还需要向XML表里面插入一条新的数据
//         setLogger(saveXml(xmlFileId, archiveId, tableId, archiveInfoJson, archivesId));
//      }
//      runTime(archiveInfoJson.getStart());
//      return result;
//   }
//
//   /***
//    * 电子文件号
//    * 文件编号
//    * 文档标识符、修改标识符
//    * 表的ID作为xml名,多次修改则拼接上修改的次数
//    *
//    * @param archiveInfoJson
//    * @param editTag
//    * @param docNumber
//    * @param archiveId
//    */
//   private void setArchAndDocNumAndTagNum(ArchiveInfoJson archiveInfoJson, int editTag, Object docNumber, String archiveId, boolean status, boolean s) {
//      //文件编号
//      archiveInfoJson.setDocNumber(docNumber.toString());
//      //文档标识符、修改标识符
//      String tagNumber = null;
//      //修改型
//      if (status) {
//         if (s) {
//            tagNumber = String.valueOf(editTag);
//         } else {
//            int i = editTag + 1;
//            tagNumber = String.valueOf(i);
//         }
//      } else {
//         tagNumber = String.valueOf(editTag);
//      }
//      archiveInfoJson.setTagNumber(tagNumber);
//      //表的ID作为xml名,多次修改则拼接上修改的次数
//      archiveInfoJson.setXmlName(archiveId);
//   }
//
//   /***
//    * 检查xml文件是否被删导致不存在或者不规范导致读取异常
//    * TODO 注意：如果文件损坏将，会生成新文件
//    *
//    * @param archiveId
//    * @return {@link Document}
//    */
//   private Document checkReadXmlRuleByDocument(String archiveId) {
//      TBasePackagefile tBasePackagefile = packageFileMapper.findAll2ObjByArchId(archiveId);
//      String pathPack = tBasePackagefile.getFilePath();
//      String savePath = fileConfig.getFileSaveRootPath("", String.valueOf(tBasePackagefile.getPathStatus()));
//      String pathNameAll = savePath + pathPack;
//      Document document;
//      if (!new File(pathNameAll).exists()) {
//         //如果文件不存在则为false
//         return null;
//      } else {
//         try {
//            document = new SAXReader().read(pathNameAll);
//            document.accept(new NameSpaceCleaner());
//         } catch (DocumentException e) {
//            //如果文件存在但是不规范读取失败则为false
//            //注意文件损坏会生成新文件
//            e.printStackTrace();
//            return null;
//         }
//      }
//      return document;
//   }
//
//   /**
//    * 获取当前登录用户对象
//    *
//    * @return
//    */
//   public User getCurrentUser() {
//      Subject user = SecurityUtils.getSubject();
//      return (User) user.getSession().getAttribute(CommonConstants.KEY_SERVER_CURRENT_USER_OBJECT);
//   }
//
//   /**
//    * 动态表解析
//    * 根据英文字段查询中文字段
//    * 且xml是否封装为是
//    * （isXml="1"）
//    *
//    * @param activeMap 动态表解析的map
//    * @param tableId   t_base_arch_table ID
//    */
//   private LinkedHashMap activeMapParse(LinkedHashMap activeMap, String tableId) {
//      LinkedHashMap map = new LinkedHashMap(16);
//      activeMap.forEach((key, value) -> {
//         //根据英文字段查询中文字段且xml是否封装为是（isXml="1"）
//         String zhName = tBaseArchTableMapper.findEnByZn(key.toString(), "1", tableId);
//         map.put(zhName, value);
//      });
//      return map;
//   }
//
//   /***
//    * 记录时间
//    *
//    * @param xmlMessage
//    */
//   private void setLogger(String xmlMessage) {
//      logger.info("对XML操作:" + xmlMessage);
//   }
//
//   /***
//    * 运行时间
//    *
//    * @param start
//    */
//   private void runTime(long start) {
//      logger.info("一共耗时:" + (System.currentTimeMillis() - start) / 1000 + "秒");
//   }
//
//   /***
//    * 新增/修改 XML数据
//    *
//    * @param xmlFileId
//    * @param archiveId
//    * @param tableId
//    * @param archiveInfoJson
//    * @param archivesId
//    * @return
//    */
//   private String saveXml(String xmlFileId, String archiveId, String tableId, ArchiveInfoJson archiveInfoJson, String archivesId) {
//      if (ApiParamsTool.isEmpty(xmlFileId, archiveId, tableId, archivesId,
//              archiveInfoJson.getSaveName(), archiveInfoJson.getMd5(), archiveInfoJson.getFilePath())) {
//         return CommonCodeEnum.XML_DATA_NOT_EXIST.getMessage();
//      }
//      TBasePackagefile basePackagefile = new TBasePackagefile();
//      basePackagefile.setPathStatus(0);
//      basePackagefile.setStatus(0);
//      basePackagefile.setArchId(archiveId);
//      basePackagefile.setArchTabId(tableId);
//      basePackagefile.setArchivesId(archivesId);
//      basePackagefile.setTableId(archiveInfoJson.getTableName());
//      basePackagefile.setFilePath(archiveInfoJson.getFilePath());
//      basePackagefile.setEditor(archiveInfoJson.getOrganizationUserName());
//      basePackagefile.setEditTime(new Timestamp(System.currentTimeMillis()));
//      basePackagefile.setCreater(archiveInfoJson.getOrganizationUserName());
//      basePackagefile.setSaveFileName(archiveInfoJson.getSaveName());
//      basePackagefile.setFondsId(archiveInfoJson.getFondsId());
//      basePackagefile.setFileSize(String.valueOf(archiveInfoJson.getFileSize()));
//      basePackagefile.setMd5(archiveInfoJson.getMd5());
//      return updateOrCreate(xmlFileId, archiveId, basePackagefile);
//   }
//
//   /***
//    * 更新或者创建
//    *
//    * @param xmlFileId
//    * @param archiveId
//    * @param basePackagefile
//    * @return
//    */
//   private String updateOrCreate(String xmlFileId, String archiveId, TBasePackagefile basePackagefile) {
//      if (packageFileMapper.checkExistByArchId(archiveId) == 0 && packageFileMapper.checkExistById(xmlFileId) == 0) {
//         try {
//            basePackagefile.setId(xmlFileId);
//            basePackagefile.setCreaterTime(new Timestamp(System.currentTimeMillis()));
//            packageFileMapper.insertXmlFile(basePackagefile);
//         } catch (Exception e) {
//            logger.error("该archid在表中已存在");
//         }
//         return CommonCodeEnum.INSERT_XML_SUCCESS.getMessage();
//      } else {
//         basePackagefile.setId(packageFileMapper.findIdByArchId(archiveId));
//         packageFileMapper.updateXmlFile(basePackagefile);
//         return CommonCodeEnum.UPDATE_SUCCESS.getMessage();
//      }
//   }
//}
//
